﻿using Elastic.Clients.Elasticsearch.IndexManagement;
using Elastic.Clients.Elasticsearch;
using Elasticsearch.Configuration;
using Microsoft.Extensions.Options;
using Elastic.Clients.Elasticsearch.Mapping;
using Elasticsearch.Model;
using Elastic.Clients.Elasticsearch.Xpack;
using Elastic.Clients.Elasticsearch.Nodes;
using Elastic.Transport;
using System.Text.Json;

namespace Elasticsearch.Service
{
    /// <summary>
    /// 索引服务实现
    /// </summary>
    public class IndexService : IIndexService
    {
        private readonly ElasticsearchClient _client;
        private readonly ElasticsearchConfig _config;
        private readonly ILogger<IndexService> _logger;

        public IndexService(ElasticsearchClient client, IOptions<ElasticsearchConfig> config, ILogger<IndexService> logger)
        {
            _client = client;
            _config = config.Value;
            _logger = logger;
        }

        ///// <summary>
        ///// 创建索引
        ///// </summary>
        //public async Task<bool> CreateIndexAsync(string indexName, object? mappings = null)
        //{
        //    try
        //    {
        //        // 检查索引是否已存在
        //        if (await IndexExistsAsync(indexName))
        //        {
        //            _logger.LogWarning("索引 {IndexName} 已存在", indexName);
        //            return true;
        //        }

        //        var createIndexRequest = new CreateIndexRequest(indexName);

        //        if (mappings != null)
        //        {
        //            createIndexRequest.Mappings = mappings;
        //        }

        //        var response = await _client.Indices.CreateAsync(createIndexRequest);

        //        if (response.IsValidResponse)
        //        {
        //            _logger.LogInformation("索引创建成功: {IndexName}", indexName);
        //            return true;
        //        }
        //        else
        //        {
        //            _logger.LogError("索引创建失败: {Error}", response.ElasticsearchServerError?.Error?.Reason);
        //            return false;
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        _logger.LogError(ex, "创建索引时发生异常: {IndexName}", indexName);
        //        return false;
        //    }
        //}

        /// <summary>
        /// 删除索引
        /// </summary>
        public async Task<bool> DeleteIndexAsync(string indexName)
        {
            try
            {
                var response = await _client.Indices.DeleteAsync(indexName);

                if (response.IsValidResponse)
                {
                    _logger.LogInformation("索引删除成功: {IndexName}", indexName);
                    return true;
                }
                else
                {
                    _logger.LogError("索引删除失败: {Error}", response.ElasticsearchServerError?.Error?.Reason);
                    return false;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "删除索引时发生异常: {IndexName}", indexName);
                return false;
            }
        }

        /// <summary>
        /// 检查索引是否存在
        /// </summary>
        public async Task<bool> IndexExistsAsync(string indexName)
        {
            try
            {
                var response = await _client.Indices.ExistsAsync(indexName);
                return response.IsValidResponse && response.Exists;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "检查索引是否存在时发生异常: {IndexName}", indexName);
                return false;
            }
        }

        /// <summary>
        /// 获取索引信息
        /// </summary>
        public async Task<object?> GetIndexInfoAsync(string indexName)
        {
            try
            {
                var response = await _client.Indices.GetAsync(indexName);

                if (response.IsValidResponse)
                {
                    return response.Indices;
                }

                return null;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "获取索引信息时发生异常: {IndexName}", indexName);
                return null;
            }
        }

        /// <summary>
        /// 获取所有索引
        /// </summary>
        //public async Task<List<string>> GetAllIndicesAsync()
        //{
        //    try
        //    {
        //        var response = await _client.Cat.IndicesAsync();

        //        if (response.IsValidResponse)
        //        {
        //            return response.Records.Select(r => r.Index).ToList();
        //        }

        //        return new List<string>();
        //    }
        //    catch (Exception ex)
        //    {
        //        _logger.LogError(ex, "获取所有索引时发生异常");
        //        return new List<string>();
        //    }
        //}

        /// <summary>
        /// 重建索引
        /// </summary>
        //public async Task<bool> ReindexAsync(string sourceIndex, string targetIndex)
        //{
        //    try
        //    {
        //        // 检查源索引是否存在
        //        if (!await IndexExistsAsync(sourceIndex))
        //        {
        //            _logger.LogError("源索引不存在: {SourceIndex}", sourceIndex);
        //            return false;
        //        }

        //        // 创建目标索引（如果不存在）
        //        if (!await IndexExistsAsync(targetIndex))
        //        {
        //            var success = await CreateIndexAsync(targetIndex);
        //            if (!success)
        //            {
        //                return false;
        //            }
        //        }

        //        var reindexRequest = new ReindexRequest
        //        {
        //            Source = new ReindexSource
        //            {
        //                Index = sourceIndex
        //            },
        //            Dest = new ReindexDestination
        //            {
        //                Index = targetIndex
        //            }
        //        };

        //        var response = await _client.ReindexAsync(reindexRequest);

        //        if (response.IsValidResponse)
        //        {
        //            _logger.LogInformation("索引重建成功: {SourceIndex} -> {TargetIndex}", sourceIndex, targetIndex);
        //            return true;
        //        }
        //        else
        //        {
        //            _logger.LogError("索引重建失败: {Error}", response.ElasticsearchServerError?.Error?.Reason);
        //            return false;
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        _logger.LogError(ex, "重建索引时发生异常: {SourceIndex} -> {TargetIndex}", sourceIndex, targetIndex);
        //        return false;
        //    }
        //}

        /// <summary>
        /// 更新索引设置
        /// </summary>
        //public async Task<bool> UpdateIndexSettingsAsync(string indexName, object settings)
        //{
        //    try
        //    {
        //        var response = await _client.Indices.PutSettingsAsync(indexName, settings);

        //        if (response.IsValidResponse)
        //        {
        //            _logger.LogInformation("索引设置更新成功: {IndexName}", indexName);
        //            return true;
        //        }
        //        else
        //        {
        //            _logger.LogError("索引设置更新失败: {Error}", response.ElasticsearchServerError?.Error?.Reason);
        //            return false;
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        _logger.LogError(ex, "更新索引设置时发生异常: {IndexName}", indexName);
        //        return false;
        //    }
        //}

        /// <summary>
        /// 创建用户索引（包含完整的映射配置）
        /// </summary>
        public async Task<bool> CreateUserIndexAsync()
        {
            try
            {

                //        // 定义索引配置
                //        var faceVectorproperties = new Properties
                //{
                //    { "Id" ,new KeywordProperty()},
                //    { "FileID" ,new KeywordProperty()},
                //    { "FileGUID" ,new KeywordProperty()},
                //    { "ResourceID" ,new KeywordProperty()},
                //    { "FileName" ,new TextProperty()},
                //    { "Embedding" ,new DenseVectorProperty{Dims = 3 } }
                //};
                //        // 定义索引配置
                //        var indexConfig = new IndexState
                //        {
                //            Settings = new IndexSettings
                //            {
                //                NumberOfShards = 1, // 设置分片数
                //                NumberOfReplicas = 1 // 设置副本数
                //            },
                //            Mappings = new TypeMapping
                //            {
                //                Properties = faceVectorproperties
                //            }
                //        };

                //var bl = await IndexExistsAsync("user");

                //var indexName = _config.DefaultIndex;


                #region 添加索引 自定义分词器
                {
                    //在 .NET 8 + Elastic.Clients.Elasticsearch 中，要使用中文拼音分词器（如 pinyin 分词器）
                    //并通过 TokenFilters 创建自定义分词器，由于新客户端是强类型的，并不支持插件型的自定义 TokenFilter
                    //（如 type = pinyin）。
                    // 检查索引是否已存在

                    //if (await IndexExistsAsync("pinyintest"))
                    //{
                    //    _logger.LogInformation("用户索引已存在: {IndexName}", "user12");
                    //    return true;
                    //}
                    //string json = """
                    //               {
                    //                 "settings": {
                    //                   "analysis": {
                    //                     "analyzer": {
                    //                       "my_pinyin_analyzer": {
                    //                         "tokenizer": "ik_max_word",
                    //                         "filter": ["my_pinyin"]
                    //                       }
                    //                     },
                    //                     "filter": {
                    //                       "my_pinyin": {
                    //                         "type": "pinyin",
                    //                         "keep_full_pinyin": false,
                    //                         "keep_joined_full_pinyin": true,
                    //                         "keep_original": true,
                    //                         "limit_first_letter_length": 16,
                    //                         "remove_duplicated_term": true,
                    //                         "none_chinese_pinyin_tokenize": false
                    //                       }
                    //                     }
                    //                   }
                    //                 },
                    //                 "mappings": {
                    //                   "properties": {
                    //                     "name": {
                    //                       "type": "text",
                    //                       "analyzer": "my_pinyin_analyzer"
                    //                     }
                    //                   }
                    //                 }
                    //               }
                    //               """
                    //;

                    //var response = await _client.Transport.RequestAsync<StringResponse>(Elastic.Transport.HttpMethod.PUT, "/pinyintest", PostData.String(json));
                    //// 正确方式：访问 response.HttpResponse.HttpStatusCode
                    //if (response.ApiCallDetails.HttpStatusCode >= 200 && response.ApiCallDetails.HttpStatusCode < 300)
                    //{
                    //    Console.WriteLine("索引创建成功");
                    //}
                    //else
                    //{
                    //    Console.WriteLine($"索引创建失败, 状态码: {response.ApiCallDetails.HttpStatusCode}");
                    //    Console.WriteLine($"响应内容: {response.Body}");
                    //}
                }
                #endregion

                #region
                {
                    // 检查索引是否已存在
                    //if (await IndexExistsAsync("user12"))
                    //{
                    //    _logger.LogInformation("用户索引已存在: {IndexName}", "user12");
                    //    return true;
                    //}

                    //var response = await _client.Indices.CreateAsync("lalla", c => c
                    //       .Settings(s => s
                    //       .NumberOfShards(3)
                    //       .NumberOfReplicas(1)
                    // //.Analysis(a =>
                    // //       a.Analyzers(an => an.Custom("my_analyzer",
                    // //             ca => ca.Tokenizer("ik_max_word")
                    // //             .Filter(new string[] { "py" })
                    // //     )).TokenFilters(tf => tf.Uppercase("", x => x.Suffix(""))
                    // //     )
                    // //)
                    // )
                    //   .Mappings(m => m
                    //       .Properties<User>(p => p
                    //           .Keyword(t => t.Id)
                    //           .Text(t => t.Username, t => t.Analyzer("standard"))
                    //           .Keyword(t => t.Email)
                    //           .Keyword(t => t.Phone)
                    //           .Text(t => t.RealName, t => t.Analyzer("standard"))
                    //           .IntegerNumber(t => t.Age, x => x.Index(false))
                    //           .IntegerNumber(t => t.Gender)
                    //           .Text(t => t.Address, t => t.Analyzer("standard"))
                    //           .IntegerNumber(t => t.Status)
                    //           .Date(t => t.CreateTime)
                    //           .Date(t => t.UpdateTime)
                    //           .Keyword(t => t.Tags)
                    //           .Flattened(t => t.Settings)
                    //       )
                    //   )
                    //);
                    //if (response.IsValidResponse)
                    //{
                    //    _logger.LogInformation("用户索引创建成功: {IndexName}", "");
                    //    //  return true;
                    //}
                    //else
                    //{
                    //    _logger.LogError("用户索引创建失败: {Error}", response.ElasticsearchServerError?.Error?.Reason);
                    //    //    return false;
                    //}
                }
                #endregion

                #region 自动补全 添加索引库
                {
                    //// 检查索引是否已存在
                    //if (await IndexExistsAsync("autocompletion"))
                    //{
                    //    _logger.LogInformation("用户索引已存在: {IndexName}", "user12");
                    //    return true;
                    //}

                    //// 创建带自动补全字段的索引
                    var createResponse = await _client.Indices.CreateAsync<Person>("autocompletion", c => c
                        .Mappings(m => m
                            .Properties(p => p
                                .Text(t => t.Name, t => t.Analyzer("standard"))
                                //.Completion(t => t.NameSuggest,t => t.Analyzer("").PreservePositionIncrements(true).PreserveSeparators(true).MaxInputLength(50))
                                .Completion(t => t.NameSuggest)
                            )
                        )
                    );
                    //Console.WriteLine(createResponse.IsValidResponse ? "✅ 索引创建成功" : $"❌ 索引创建失败: {JsonSerializer.Serialize(createResponse)}");
                }
                #endregion

                //var createIndexRequest = new CreateIndexRequest(indexName)
                //{
                //    Mappings = mappings,
                //    Settings = new IndexSettings() {

                //        NumberOfShards = 1, // 设置分片数
                //        NumberOfReplicas = 1 // 设置副本数
                //    }
                //};

                //var response = await _client.Indices.CreateAsync(createIndexRequest);

                return true;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "创建用户索引时发生异常");
                return false;
            }
        }

        //public Task<bool> CreateIndexAsync(string indexName, object? mappings = null)
        //{
        //    throw new NotImplementedException();
        //}
    }
}
